// numeric standard header
#pragma once
#ifndef _NUMERIC_
#define _NUMERIC_
#ifndef RC_INVOKED
#include <xutility>

 #pragma pack(push,_CRT_PACKING)
 #pragma warning(push,_STL_WARNING_LEVEL)
 #pragma warning(disable: _STL_DISABLED_WARNINGS)
 #pragma push_macro("new")
 #undef new
_STD_BEGIN
		// FUNCTION TEMPLATE accumulate WITH BINOP
template<class _InIt,
	class _Ty,
	class _Fn2> inline
	_Ty _Accumulate_unchecked(_InIt _First, _InIt _Last, _Ty _Val, _Fn2& _Func)
	{	// return sum of _Val and all in [_First, _Last), using _Func
	for (; _First != _Last; ++_First)
		_Val = _Func(_Val, *_First);
	return (_Val);
	}

template<class _InIt,
	class _Ty,
	class _Fn2> inline
	_Ty accumulate(_InIt _First, _InIt _Last, _Ty _Val, _Fn2 _Func)
	{	// return sum of _Val and all in [_First, _Last), using _Func
	_DEBUG_RANGE(_First, _Last);
	return (_Accumulate_unchecked(_Unchecked(_First), _Unchecked(_Last), _Val, _Func));
	}

		// FUNCTION TEMPLATE accumulate
template<class _InIt,
	class _Ty> inline
	_Ty accumulate(_InIt _First, _InIt _Last, _Ty _Val)
	{	// return sum of _Val and all in [_First, _Last)
	return (_STD accumulate(_First, _Last, _Val, plus<>()));
	}

		// FUNCTION TEMPLATE inner_product WITH BINOPS
template<class _InIt1,
	class _InIt2,
	class _Ty,
	class _Fn21,
	class _Fn22> inline
	_Ty _Inner_product_unchecked(_InIt1 _First1, _InIt1 _Last1,
		_InIt2 _First2, _Ty _Val,
		_Fn21& _Func1, _Fn22& _Func2)
	{	// return inner product of sequences, using _Func1 and _Func2
	for (; _First1 != _Last1; ++_First1, (void)++_First2)
		_Val = _Func1(_Val, _Func2(*_First1, *_First2));
	return (_Val);
	}

template<class _InIt1,
	class _InIt2,
	class _Ty,
	class _Fn21,
	class _Fn22> inline
	_Ty _Inner_product_no_deprecate(_InIt1 _First1, _InIt1 _Last1,
		_InIt2 _First2, _Ty _Val,
		_Fn21& _Func1, _Fn22& _Func2)
	{	// return inner product of sequences, using _Func1 and _Func2, no deprecation warnings
	_DEBUG_RANGE(_First1, _Last1);
	const auto _UFirst1 = _Unchecked(_First1);
	const auto _ULast1 = _Unchecked(_Last1);
	const auto _UFirst2 = _Unchecked_n(_First2, _Idl_distance(_UFirst1, _ULast1));
	return (_Inner_product_unchecked(_UFirst1, _ULast1, _UFirst2, _Val, _Func1, _Func2));
	}

template<class _InIt1,
	class _InIt2,
	class _Ty,
	class _Fn21,
	class _Fn22> inline
	_Ty inner_product(_InIt1 _First1, _InIt1 _Last1,
		_InIt2 _First2, _Ty _Val,
		_Fn21 _Func1, _Fn22 _Func2)
	{	// return inner product of sequences, using _Func1 and _Func2
	_DEPRECATE_UNCHECKED(inner_product, _First2);
	return (_Inner_product_no_deprecate(_First1, _Last1, _First2, _Val, _Func1, _Func2));
	}

 #if _ITERATOR_DEBUG_ARRAY_OVERLOADS
template<class _InIt1,
	class _InTy,
	size_t _InSize,
	class _Ty,
	class _Fn21,
	class _Fn22> inline
	_Ty inner_product(_InIt1 _First1, _InIt1 _Last1,
		_InTy (&_First2)[_InSize], _Ty _Val,
		_Fn21 _Func1, _Fn22 _Func2)
	{	// return inner product of sequences, using _Func1 and _Func2
	return (_Inner_product_no_deprecate(_First1, _Last1,
		_Array_iterator<_InTy, _InSize>(_First2), _Val,
		_Func1, _Func2));
	}
 #endif /* _ITERATOR_DEBUG_ARRAY_OVERLOADS */

		// FUNCTION TEMPLATE inner_product
template<class _InIt1,
	class _InIt2,
	class _Ty> inline
	_Ty inner_product(_InIt1 _First1, _InIt1 _Last1,
		_InIt2 _First2, _Ty _Val)
	{	// return inner product of sequences
	return (_STD inner_product(_First1, _Last1, _First2, _Val,
		plus<>(), multiplies<>()));
	}

 #if _ITERATOR_DEBUG_ARRAY_OVERLOADS
template<class _InIt1,
	class _InTy,
	size_t _InSize,
	class _Ty> inline
	_Ty inner_product(_InIt1 _First1, _InIt1 _Last1,
		_InTy (&_First2)[_InSize], _Ty _Val)
	{	// return inner product of sequences
	return (_STD inner_product(_First1, _Last1, _First2, _Val,
		plus<>(), multiplies<>()));
	}
 #endif /* _ITERATOR_DEBUG_ARRAY_OVERLOADS */

		// FUNCTION TEMPLATE partial_sum WITH BINOP
template<class _InIt,
	class _OutIt,
	class _Fn2> inline
	_OutIt _Partial_sum_unchecked(_InIt _First, _InIt _Last,
		_OutIt _Dest, _Fn2& _Func)
	{	// compute partial sums into _Dest, using _Func
	if (_First != _Last)
		{
		_Iter_value_t<_InIt> _Val = *_First;
		for (*_Dest = _Val; ++_First != _Last; *++_Dest = _Val)
			_Val = _Func(_Val, *_First);
		++_Dest;
		}

	return (_Dest);
	}

template<class _InIt,
	class _OutIt,
	class _Fn2> inline
	_OutIt _Partial_sum_no_deprecate(_InIt _First, _InIt _Last,
		_OutIt _Dest, _Fn2& _Func)
	{	// compute partial sums into _Dest, using _Func, no deprecation warnings
	_DEBUG_RANGE(_First, _Last);
	const auto _UFirst = _Unchecked(_First);
	const auto _ULast = _Unchecked(_Last);
	const auto _UDest = _Unchecked_n(_Dest, _Idl_distance(_UFirst, _ULast));
	return (_Rechecked(_Dest,
		_Partial_sum_unchecked(_UFirst, _ULast, _UDest, _Func)));
	}

template<class _InIt,
	class _OutIt,
	class _Fn2> inline
	_OutIt partial_sum(_InIt _First, _InIt _Last,
		_OutIt _Dest, _Fn2 _Func)
	{	// compute partial sums into _Dest, using _Func
	_DEPRECATE_UNCHECKED(partial_sum, _Dest);
	return (_Partial_sum_no_deprecate(_First, _Last, _Dest, _Func));
	}

 #if _ITERATOR_DEBUG_ARRAY_OVERLOADS
template<class _InIt,
	class _OutTy,
	size_t _OutSize,
	class _Fn2> inline
	_OutTy *partial_sum(_InIt _First, _InIt _Last,
		_OutTy (&_Dest)[_OutSize], _Fn2 _Func)
	{	// compute partial sums into _Dest, using _Func
	return (_Unchecked(
		_Partial_sum_no_deprecate(_First, _Last,
			_Array_iterator<_OutTy, _OutSize>(_Dest), _Func)));
	}
 #endif /* _ITERATOR_DEBUG_ARRAY_OVERLOADS */

		// FUNCTION TEMPLATE partial_sum
template<class _InIt,
	class _OutIt> inline
	_OutIt partial_sum(_InIt _First, _InIt _Last,
		_OutIt _Dest)
	{	// compute partial sums into _Dest
	return (_STD partial_sum(_First, _Last, _Dest, plus<>()));
	}

 #if _ITERATOR_DEBUG_ARRAY_OVERLOADS
template<class _InIt,
	class _OutTy,
	size_t _OutSize> inline
	_OutTy *partial_sum(_InIt _First, _InIt _Last,
		_OutTy (&_Dest)[_OutSize])
	{	// compute partial sums into _Dest
	return (_STD partial_sum(_First, _Last, _Dest, plus<>()));
	}
 #endif /* _ITERATOR_DEBUG_ARRAY_OVERLOADS */

		// FUNCTION TEMPLATE adjacent_difference WITH BINOP
template<class _InIt,
	class _OutIt,
	class _Fn2> inline
	_OutIt _Adjacent_difference_unchecked(_InIt _First, _InIt _Last,
		_OutIt _Dest, _Fn2& _Func)
	{	// compute adjacent differences into _Dest, using _Func
	if (_First != _Last)
		{
		_Iter_value_t<_InIt> _Val = *_First;
		for (*_Dest = _Val; ++_First != _Last; )
			{	// compute another difference
			_Iter_value_t<_InIt> _Tmp = *_First;
			*++_Dest = _Func(_Tmp, _Val);
			_Val = _STD move(_Tmp);
			}
		++_Dest;
		}

	return (_Dest);
	}

template<class _InIt,
	class _OutIt,
	class _Fn2> inline
	_OutIt _Adjacent_difference_no_deprecate(_InIt _First, _InIt _Last,
		_OutIt _Dest, _Fn2& _Func)
	{	// compute adjacent differences into _Dest, using _Func, no deprecation warnings
	_DEBUG_RANGE(_First, _Last);
	const auto _UFirst = _Unchecked(_First);
	const auto _ULast = _Unchecked(_Last);
	const auto _UDest = _Unchecked_n(_Dest, _Idl_distance(_UFirst, _ULast));
	return (_Rechecked(_Dest,
		_Adjacent_difference_unchecked(_UFirst, _ULast, _UDest, _Func)));
	}

template<class _InIt,
	class _OutIt,
	class _Fn2> inline
	_OutIt adjacent_difference(_InIt _First, _InIt _Last,
		_OutIt _Dest, _Fn2 _Func)
	{	// compute adjacent differences into _Dest, using _Func
	_DEPRECATE_UNCHECKED(adjacent_difference, _Dest);
	return (_Adjacent_difference_no_deprecate(_First, _Last, _Dest, _Func));
	}

 #if _ITERATOR_DEBUG_ARRAY_OVERLOADS
template<class _InIt,
	class _OutTy,
	size_t _OutSize,
	class _Fn2> inline
	_OutTy *adjacent_difference(_InIt _First, _InIt _Last,
		_OutTy (&_Dest)[_OutSize], _Fn2 _Func)
	{	// compute adjacent differences into _Dest, using _Func
	return (_Unchecked(
		_Adjacent_difference_no_deprecate(_First, _Last,
			_Array_iterator<_OutTy, _OutSize>(_Dest), _Func)));
	}
 #endif /* _ITERATOR_DEBUG_ARRAY_OVERLOADS */

		// FUNCTION TEMPLATE adjacent_difference
template<class _InIt,
	class _OutIt> inline
	_OutIt adjacent_difference(_InIt _First, _InIt _Last,
		_OutIt _Dest)
	{	// compute adjacent differences into _Dest
	return (_STD adjacent_difference(_First, _Last, _Dest,
		minus<>()));
	}

 #if _ITERATOR_DEBUG_ARRAY_OVERLOADS
template<class _InIt,
	class _OutTy,
	size_t _OutSize> inline
	_OutTy *adjacent_difference(_InIt _First, _InIt _Last,
		_OutTy (&_Dest)[_OutSize])
	{	// compute adjacent differences into _Dest
	return (_STD adjacent_difference(_First, _Last, _Dest,
		minus<>()));
	}
 #endif /* _ITERATOR_DEBUG_ARRAY_OVERLOADS */

template<class _FwdIt,
	class _Ty> inline
	void _Iota_unchecked(_FwdIt _First, _FwdIt _Last, _Ty _Val)
	{	// compute increasing sequence into [_First, _Last)
	for (; _First != _Last; ++_First, (void)++_Val)
		*_First = _Val;
	}

template<class _FwdIt,
	class _Ty> inline
	void iota(_FwdIt _First, _FwdIt _Last, _Ty _Val)
	{	// compute increasing sequence into [_First, _Last)
	_DEBUG_RANGE(_First, _Last);
	_Iota_unchecked(_Unchecked(_First), _Unchecked(_Last), _Val);
	}
_STD_END
 #pragma pop_macro("new")
 #pragma warning(pop)
 #pragma pack(pop)
#endif /* RC_INVOKED */
#endif /* _NUMERIC_ */

/*
 * Copyright (c) by P.J. Plauger. All rights reserved.
 * Consult your license regarding permissions and restrictions.
V6.50:0009 */
